Programming Ruby: The Pragmatic Programmers' Guide (Second Edition): The Art of Flexible Method Definitions

Ruby elevates method definitions from rigid signatures to dynamic interfaces. By mastering the Splat operator and expression-based logic, we create methods that adapt gracefully to varying data densities without needing complex overloads.

1. Intelligent Defaults & Splats

Ruby allows parameters to be initialized within the signature, ensuring functionality even with minimal data. The Splat operator (*) acts as a bridge: in parameters, it captures extra arguments into an array; in calls, it 'explodes' an array into individual slots.

2. Expression-Based Returns

Ruby methods automatically return the value of the last expression executed. However, the return keyword is used strategically to exit early or return multiple values as an array for parallel assignment.

num, sq = meth_three
# Ruby packages (num, sq) as an array [32, 1024]

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What is the primary role of the asterisk (*) in a method parameter list?

To mark a variable as a pointer to a memory address.

To capture a variable number of arguments into a single array.

To multiply the incoming argument by its index.

To indicate the method is private.

QUESTION 2

Given `def show(x, y=10)`, what happens if you call `show(5)`?

An ArgumentError is raised because two arguments are required.

x becomes 5 and y becomes 10.

x becomes 5 and y becomes nil.

The method returns 15 automatically.

QUESTION 3

What does 'Array Expansion' (Exploding) refer to in a method call?

Converting a string into an array of characters.

Deleting all elements in an array to free memory.

Using `*` before an array to pass its elements as individual arguments.

Expanding the heap to accommodate larger arrays.

QUESTION 4

If a Ruby method has no explicit `return` keyword, what does it return?

It returns nil by default.

It returns true if the code executed successfully.

It returns the value of the last expression evaluated.

It returns the name of the method as a string.

QUESTION 5

How are multiple return values handled in `return a, b`?

Ruby only returns the first value (a).

Ruby returns an array `[a, b]` which can be destructured.

It results in a syntax error; only one value can be returned.

The values are added together before returning.

Flexible Logging System Case Study

Designing an adaptive interface

You are building a logging system. Usually, you only pass a message. Occasionally, you need to pass a list of error codes. You define the method: `def log(msg='Info', *codes)`. The codes should be joined into a string if present.

If you call `log()`, what are the values of `msg` and `codes` inside the method?

Solution:
`msg` will be 'Info' (the default value) and `codes` will be an empty array `[]`.

If you have an array `errs = [404, 500]`, how do you call `log` so 'Critical' is the message and the errors are captured in the `codes` array?

Solution:
Call it using the splat operator: `log('Critical', *errs)`. This explodes the array into individual arguments after the first one.

How does Ruby's expression-based return benefit this logger if the last line is `codes.empty? ? msg : "#{msg}: #{codes.join(', ')}"`?

Solution:
The method automatically returns the formatted string without needing an explicit `return` keyword, making the code more concise and readable.